{
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"# Remote computing with Perceval"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Here we aim at showing how to connect to Quandela's cloud services to perform computation with real QPU and simulators remotely. We are going to use a simple two modes circuit here.\n",
"\n",
"Please note that other Cloud providers exist besides Quandela, see [providers](https://perceval.quandela.net/docs/providers.html) for additional information."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import time\n",
"import numpy as np\n",
"from tqdm.notebook import tqdm\n",
"\n",
"import perceval as pcvl\n",
"from perceval.algorithm import Sampler"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"First, define your objects through Perceval as usual."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
""
],
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"input_state = pcvl.BasicState([1, 1])\n",
"\n",
"c = pcvl.Circuit(2)\n",
"c.add(0, pcvl.BS())\n",
"c.add(0, pcvl.PS(phi = np.pi/4))\n",
"c.add(0, pcvl.BS())\n",
"\n",
"pcvl.pdisplay(c)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Now, visit [cloud.quandela.com](https://cloud.quandela.com) and login to see which QPU and simulators are available, as well as their specifications. Once you have chosen, all you have to do is to copy the machine's name. You can now define a `RemoteProcessor` using the name of the machine and your token. Before using your token, don't forget to give it the right to be used on the machine you want."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# Use your key here to let the system know who you are\n",
"token_qcloud = 'YOUR_API_KEY'\n",
"remote_simulator = pcvl.RemoteProcessor(\"sim:ascella\", token_qcloud)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"You can now access to the specificities of the machine directly in Perceval."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
""
],
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"specs = remote_simulator.specs\n",
"pcvl.pdisplay(specs[\"specific_circuit\"])"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'max_mode_count': 12, 'max_photon_count': 6, 'min_mode_count': 1, 'min_photon_count': 1}\n",
"{'HOM': 'indistinguishability value, using HOM model (default 1)', 'backend_name': 'name of the backend that will be used for computation (default \"SLOS\")', 'final_mode_number': 'number of modes of the output states. states having a photon on unused modes will be ignored. Useful when using computed circuits (default input_state.m)', 'g2': 'g2 value (default 0)', 'min_detected_photons': 'minimum number of detected photons to keep a state (default input_state.n)', 'phase_imprecision': 'imprecision on the phase shifter phases (default 0)', 'transmittance': 'probability that an emitted photon is sent to the system and is detected (default 1)'}\n"
]
}
],
"source": [
"print(specs[\"constraints\"])\n",
"print(specs[\"parameters\"])"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Now we have to specify what parameters we want to give to compute. For specific parameters, we have to use a special `set_parameter` function (or `set_parameters`)."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"remote_simulator.set_circuit(c)\n",
"remote_simulator.with_input(input_state)\n",
"\n",
"remote_simulator.set_parameters({\n",
" \"HOM\": .95,\n",
" \"transmittance\": .1,\n",
" \"g2\": .01\n",
"})\n",
"remote_simulator.min_detected_photons_filter(1)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"We can now use the `Sampler` with our `RemoteProcessor`."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"sampler = Sampler(remote_simulator)\n",
"sampler.default_job_name = \"My sampling job\" # All jobs created by this sampler instance will have this custom name on the cloud\n",
"\n",
"nsample = 200000\n",
"remote_job = sampler.sample_count.execute_async(nsample)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"The order has now been sent to a distant computer. As it is an async computation, we can do other things locally before the results arrive. In our case, we will just wait for the end of the computation. If you go to the cloud website again, you could see the job and its completion status."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "fa3e0674763d422aad8e3fc4aa7ba725",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| |"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Job status = SUCCESS\n"
]
}
],
"source": [
"previous_prog = 0\n",
"with tqdm(total=1, bar_format='{desc}{percentage:3.0f}%|{bar}|') as tq:\n",
" tq.set_description(f'Get {nsample} samples from {remote_simulator.name}')\n",
" while not remote_job.is_complete:\n",
" tq.update(remote_job.status.progress/100-previous_prog)\n",
" previous_prog = remote_job.status.progress/100\n",
" time.sleep(1)\n",
" tq.update(1-previous_prog)\n",
" tq.close()\n",
"\n",
"print(f\"Job status = {remote_job.status()}\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Once the previous cell has stopped, the job is finished (again, you can see its status on the website). We can now retrieve the results to do some computation. Here, the computation should be relatively fast (unless the simulator is unavailable or there are many requests on it), so we can use the job object we created before. If the computation lasted for a long time, we could have created a new job object and directly retrieved the result given the job id that is visible on the website."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{\n",
" |1,0>: 99022\n",
" |0,1>: 98858\n",
" |1,1>: 2120\n",
"}\n"
]
}
],
"source": [
"''' # To retrieve your job using a job id\n",
"remote_processor = pcvl.RemoteProcessor(\"sim:ascella\", token_qcloud)\n",
"async_job = remote_processor.resume_job(id)\n",
"'''\n",
"\n",
"results = remote_job.get_results()\n",
"print(results['results'])"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"You can run the same sampling on the corresponding QPU:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"remote_qpu = pcvl.RemoteProcessor(\"qpu:ascella\", token_qcloud)\n",
"remote_qpu.set_circuit(c)\n",
"remote_qpu.with_input(input_state)\n",
"remote_qpu.min_detected_photons_filter(1)\n",
"\n",
"sampler_on_qpu = Sampler(remote_qpu)\n",
"\n",
"nsample = 200000\n",
"remote_job = sampler_on_qpu.sample_count\n",
"remote_job.name = \"QPU sampling\" # You may also specify a name to individual jobs\n",
"remote_job.execute_async(nsample);"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "95d6787d6d064282a327870a91a3a445",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| |"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Job status = SUCCESS\n"
]
}
],
"source": [
"previous_prog = 0\n",
"with tqdm(total=1, bar_format='{desc}{percentage:3.0f}%|{bar}|') as tq:\n",
" tq.set_description(f'Get {nsample} samples from {remote_qpu.name}')\n",
" while not remote_job.is_complete:\n",
" tq.update(remote_job.status.progress/100-previous_prog)\n",
" previous_prog = remote_job.status.progress/100\n",
" time.sleep(1)\n",
" tq.update(1-previous_prog)\n",
" tq.close()\n",
"\n",
"print(f\"Job status = {remote_job.status()}\")"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{\n",
" |1,0>: 211538\n",
" |0,1>: 178621\n",
" |1,1>: 5013\n",
"}\n"
]
}
],
"source": [
"results = remote_job.get_results()\n",
"print(results['results'])"
]
}
],
"metadata": {
"language_info": {
"name": "python"
}
},
"nbformat": 4,
"nbformat_minor": 1
}